
#include <iostream>
#include <opencv2/opencv.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/xfeatures2d.hpp>
#include <opencv2/calib3d.hpp>
#include <opencv2/imgproc.hpp>
#include <vector>
using namespace std;
using namespace cv;
using namespace cv::xfeatures2d;

typedef struct
{
    //四个顶点
    Point2f left_top;
    Point2f left_bottom;
    Point2f right_top;
    Point2f right_bottom;
}four_corners_t;

four_corners_t corners;

//计算配准图的四个顶点坐标
void CalcCorners(const Mat& H, const Mat& src)
{
    double v2[] = { 0, 0, 1 };//左上角
    double v1[3];//变换后的坐标值

    Mat V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
    Mat V1 = Mat(3, 1, CV_64FC1, v1);  //列向量

    V1 = H * V2;
    //左上角(0,0,1)
    cout << "V2: " << V2 << endl;
    cout << "V1: " << V1 << endl;
    corners.left_top.x = v1[0] / v1[2];
    corners.left_top.y = v1[1] / v1[2];

    //左下角(0,src.rows,1)
    v2[0] = 0;
    v2[1] = src.rows;
    v2[2] = 1;
    V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
    V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
    V1 = H * V2;
    corners.left_bottom.x = v1[0] / v1[2];
    corners.left_bottom.y = v1[1] / v1[2];

    //右上角(src.cols,0,1)
    v2[0] = src.cols;
    v2[1] = 0;
    v2[2] = 1;
    V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
    V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
    V1 = H * V2;
    corners.right_top.x = v1[0] / v1[2];
    corners.right_top.y = v1[1] / v1[2];

    //右下角(src.cols,src.rows,1)
    v2[0] = src.cols;
    v2[1] = src.rows;
    v2[2] = 1;
    V2 = Mat(3, 1, CV_64FC1, v2);  //列向量
    V1 = Mat(3, 1, CV_64FC1, v1);  //列向量
    V1 = H * V2;
    corners.right_bottom.x = v1[0] / v1[2];
    corners.right_bottom.y = v1[1] / v1[2];

}

//优化两图的连接处，使得拼接自然
void OptimizeSeam(Mat& img1, Mat& trans, Mat& dst)
{
    int start = MIN(corners.left_top.x, corners.left_bottom.x);//开始位置，即重叠区域的左边界

    double processWidth = img1.cols - start;//重叠区域的宽度
    int rows = dst.rows;
    int cols = img1.cols; //注意，是列数*通道数
    double alpha = 1;//img1中像素的权重
    for (int i = 0; i < rows; i++)
    {
        uchar* p = img1.ptr<uchar>(i);  //获取第i行的首地址
        uchar* t = trans.ptr<uchar>(i);
        uchar* d = dst.ptr<uchar>(i);
        for (int j = start; j < cols; j++)
        {
            //如果遇到图像trans中无像素的黑点，则完全拷贝img1中的数据
            if (t[j * 3] == 0 && t[j * 3 + 1] == 0 && t[j * 3 + 2] == 0)
            {
                alpha = 1;
            }
            else
            {
                //img1中像素的权重，与当前处理点距重叠区域左边界的距离成正比，实验证明，这种方法确实好
                alpha = (processWidth - (j - start)) / processWidth;
            }

            d[j * 3] = p[j * 3] * alpha + t[j * 3] * (1 - alpha);
            d[j * 3 + 1] = p[j * 3 + 1] * alpha + t[j * 3 + 1] * (1 - alpha);
            d[j * 3 + 2] = p[j * 3 + 2] * alpha + t[j * 3 + 2] * (1 - alpha);

        }
    }

}



int main(int argc, char *argv[])
{
    Mat left=imread("/Users/hnxf/workspc/qt-demo/ImageStitching/pic/0.jpg");
    Mat right=imread("/Users/hnxf/workspc/qt-demo/ImageStitching/pic/1.jpg");

    Ptr<SURF>surf;   //特征点
    // hessian 关键点阈值
    int nThresholdHessian = 1000;
    surf = SURF::create(nThresholdHessian);

    //匹配器
    BFMatcher matcher;

    vector<KeyPoint>vec_key_point_left_,vec_key_point_right_;
    Mat mat_detech_lift_;
    Mat mat_detech_right_;

    //检测出SURF特征关键点
    surf->detectAndCompute(left,Mat(),vec_key_point_left_,mat_detech_lift_);
    surf->detectAndCompute(right,Mat(),vec_key_point_right_,mat_detech_right_);

    //保存特征点对比
    vector<DMatch>matches;
    matcher.match(mat_detech_lift_,mat_detech_right_,matches);

    //排序 从小到大
    sort(matches.begin(),matches.end());

    //保留最优的特征点对象
    vector<DMatch>good_matches;

    //设置比例30， 50， 60， 70
    int ptrPoint = std::min(20,(int)(matches.size()*0.15));

    for(int i = 0;i < ptrPoint;i++)
    {
        good_matches.push_back(matches[i]);
    }

    //最佳匹配的特征点连成线
    Mat outimg;

    drawMatches(left,vec_key_point_left_,right,vec_key_point_right_,good_matches,outimg,
                Scalar::all(-1),Scalar::all(-1),
                vector<char>(),DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);

    imshow("outimg",outimg);


    //特征点配准
    vector<Point2f>imagepoint1,imagepoint2;

    for(int i = 0;i<good_matches.size();i++)
    {
        imagepoint1.push_back(vec_key_point_right_[good_matches[i].trainIdx].pt);
        imagepoint2.push_back(vec_key_point_left_[good_matches[i].queryIdx].pt);
    }

    //透视转换
    Mat homo = findHomography(imagepoint1,imagepoint2,RANSAC);


    //四个顶点坐标的转换计算
    CalcCorners(homo,right);

    Mat imageTranForm;
    warpPerspective(right,imageTranForm,homo,
                    Size(MAX(corners.right_top.x,
                             corners.right_bottom.x),
                         left.rows));

    //创建拼接后的图，计算图的大小
    int dst_width = imageTranForm.cols;
    int dst_height = left.rows;

    Mat dst(dst_height,dst_width,CV_8UC3);
    dst.setTo(0);

    imageTranForm.copyTo(dst(Rect(0,0,imageTranForm.cols,imageTranForm.rows)));
    left.copyTo(dst(Rect(0,0,left.cols,left.rows)));

    //优化拼接，主要目的去除黑边
    OptimizeSeam(left,imageTranForm, dst);

    imshow("dst",dst);

    waitKey(0);

    return 0;
}

